package org.club.Controller;


import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.club.Service.UserService;
import org.club.common.model.dto.*;
import org.club.common.model.entity.AnnouncementWithReadStatus;
import org.club.common.model.entity.BusinessException;
import org.club.common.model.entity.ClubActivityInfo;
import org.club.common.model.entity.Clubs;
import org.club.common.model.vo.ClubsDetailVO;
import org.club.common.model.vo.*;
import org.club.common.util.ApiResponseMe;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@RestController
@RequestMapping("/userclubs")
@Tag(name = "普通用户", description = "加入社团等")
@Slf4j
public class UserController {
    @Autowired
    private UserService userService;


    /**
     * 获取社团列表和总数
     *
     * @param clubInfoDto 包含社团信息的DTO，用于筛选社团列表
     * @param userId      用户ID，用于获取个性化社团列表
     * @return 返回包含社团列表和总数的响应对象
     */
    @PostMapping("/list")
    public ApiResponseMe list(@RequestBody ClubInfoDto clubInfoDto, @RequestParam Long userId) {
        List<ClubInfoVO> list = userService.selectClubsList(clubInfoDto, userId);
        Integer total = userService.selectClubsListTotal();
        PageResponse<ClubInfoVO> userInfoVOPageResponse = new PageResponse<>(list, total);
        return ApiResponseMe.success(userInfoVOPageResponse);
    }

    /**
     * 加入社团
     *
     * @param clubId   社团ID，标识要加入的社团
     * @param username 用户名，标识要加入社团的用户
     * @return 返回表示操作结果的响应对象
     */
    @PostMapping("/joinClub")
    public ApiResponseMe joinClub(@RequestParam Long clubId, @RequestParam String username) {
        userService.joinClub(clubId, username);
        return ApiResponseMe.shape(true, "加入社团成功");
    }

    /**
     * 获取用户已加入的社团列表
     *
     * @param userId 用户ID，用于获取该用户加入的社团列表
     * @return 返回包含用户已加入社团列表的响应对象
     */
    @GetMapping("/selectClubs")
    public ApiResponseMe selectClubs(@RequestParam Long userId) {
        List<ClubInfoVO> list = userService.selectjoinClubsList(userId);
        return ApiResponseMe.success(list);
    }

    /**
     * 处理用户退出社团的请求
     *
     * @param clubId 社团的唯一标识符
     * @param userId 用户的唯一标识符
     * @return 返回一个包含操作结果的ApiResponseMe对象
     */
    @PostMapping("/quitClub")
    public ApiResponseMe quitClub(@RequestParam Long clubId, @RequestParam Long userId) {
        // 调用userService的quitClub方法处理用户退出社团的逻辑
        userService.quitClub(clubId, userId);
        // 返回成功信息
        return ApiResponseMe.shape(true, "退出社团成功");
    }


    /**
     * 通过GET请求查询社团发布的活动列表
     *
     * @param clubId 社团ID，用于查询特定社团的活动
     * @return 返回一个ApiResponseMe对象，其中包含查询结果或错误信息
     */
    @GetMapping("/selectActivities")
    public ApiResponseMe selectActivities(@RequestParam Long clubId) {
        try {
            // 调用userService的selectActivities方法查询社团活动列表
            List<ActivitiesVO> list = userService.selectActivities(clubId);
            // 日志记录查询成功信息
            log.info("查询社团发布的活动列表成功{}", list);
            // 返回查询结果
            return ApiResponseMe.success(list);
        } catch (BusinessException e) {
            // 记录异常信息
            e.printStackTrace();
            // 返回错误响应，包含错误代码和消息
            return ApiResponseMe.error(400, e.getMessage());
        }
    }

    /**
     * 处理用户报名活动的请求
     *
     * @param activityId 活动的唯一标识符
     * @param userId     用户的唯一标识符
     * @return 返回一个包含报名结果的ApiResponseMe对象
     */
    @PostMapping("/signUpActivity")
    public ApiResponseMe signUpActivity(@RequestParam Long activityId, @RequestParam Long userId) {
        // 调用userService的signUpActivity方法进行报名操作
        userService.signUpActivity(activityId, userId);
        // 返回报名成功的响应
        return ApiResponseMe.shape(true, "报名成功");
    }


    /**
     * 查询所有活动
     * 该方法通过POST请求接收ActivityQueryDTO对象，用于查询符合条件的所有活动
     * 主要用于后台管理界面或需要筛选功能的界面，以获取全面的活动信息
     *
     * @param activityQueryDTO 包含查询条件的DTO对象
     * @return 包含活动列表的ApiResponseMe对象
     */
    @PostMapping("/selectAllActivities")
    public ApiResponseMe selectAllActivities(@RequestBody ActivityQueryDTO activityQueryDTO) {
        List<ActivitiesNumberApplicantsVO> list = userService.selectAllActivities(activityQueryDTO);
        log.info("查询所有活动成功{}", list);
        return ApiResponseMe.success(list);
    }

    /**
     * 查询用户报名的活动列表
     * 该方法通过GET请求接收用户ID、活动状态和关键词参数，以查询用户报名的活动
     * 主要用于用户界面，以便用户可以查看自己报名的活动状态
     *
     * @param userId  用户ID，必填参数
     * @param status  活动状态，可选参数
     * @param keyword 搜索关键词，可选参数
     * @return 包含用户报名活动列表的ApiResponseMe对象
     */
    @GetMapping("/selectUserSignUpActivities")
    public ApiResponseMe selectUserSignUpActivities(
            @RequestParam Long userId,
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) String keyword) {
        try {
            List<Registration_InformationVO> list = userService.selectUserSignUpActivities(userId, status, keyword);
            log.info("查询用户报名的活动列表成功{}", list);
            return ApiResponseMe.success(list);
        } catch (BusinessException e) {
            e.printStackTrace();
            return ApiResponseMe.error(400, e.getMessage());
        }
    }

    /**
     * 创建社团
     *
     * @param file     社团的相关文件，如社团图标或宣传图片
     * @param clubsDto 社团的信息数据传输对象
     * @param user_id  用户ID，用于关联创建者，默认为0
     * @return 返回API响应对象，包含处理结果
     */
    @PostMapping("/CreateCommunity")
    public ApiResponseMe CreateCommunity(@RequestPart("file") MultipartFile file, @RequestPart("clubs") ClubsDto clubsDto, @RequestParam(value = "user_id", required = false, defaultValue = "0") Long user_id) {
        // 调用社团服务的创建方法，传入社团信息、创建者ID和相关文件
        userService.CreateCommunity(clubsDto, user_id, file);
        // 创建成功，返回成功响应
        return ApiResponseMe.shape(true, "创建社团申请提交成功");
    }


    /**
     * 通过GET请求查询社团创建进度
     * 此方法接收一个用户ID作为参数，并返回该用户的社团创建进度信息
     * 使用Logging记录查询操作的成功信息，包括用户ID
     * 通过调用userService的selectClubsProcess方法来获取社团创建进度
     * 返回包含社团创建进度信息的成功响应
     *
     * @param userId 用户ID，用于查询社团创建进度
     * @return 包含社团创建进度信息的ApiResponseMe对象
     */
    @GetMapping("/selectClubsCreateProgress")
    public ApiResponseMe selectClubsProcess(@RequestParam Long userId) {
        // 记录查询社团创建进度成功的日志信息
        log.info("查询社团创建进度成功{}", userId);
        // 调用服务层方法获取社团创建进度
        Clubs clubs = userService.selectClubsProcess(userId);
        // 返回包含社团创建进度信息的成功响应
        return ApiResponseMe.success(clubs);
    }


    /**
     * 选择系统公告
     *
     * @param announcementQueryDTO 公告查询DTO，包含查询条件
     * @return 包含公告列表的ApiResponseMe对象
     */
    @PostMapping("/selectSystemAnnouncements")
    public ApiResponseMe selectSystemAnnouncements(@RequestBody AnnouncementQueryDTO announcementQueryDTO) {
        List<AnnouncementWithReadStatus> list = userService.selectSystemAnnouncements(announcementQueryDTO);
        return ApiResponseMe.success(list);
    }

    /**
     * 选择未读公告数量
     *
     * @param userId 用户ID
     * @return 包含未读公告数量的ApiResponseMe对象
     */
    @GetMapping("/selectUnreadCount")
    public ApiResponseMe selectUnreadCount(@RequestParam Long userId) {
        return ApiResponseMe.success(userService.selectUnreadCount(userId));
    }

    /**
     * 更新公告阅读状态
     *
     * @param announcement_id 公告ID
     * @return 表示操作成功的ApiResponseMe对象
     */
    @PostMapping("/updateAnnouncementReadStatus")
    public ApiResponseMe updateAnnouncementReadStatus(@RequestParam Long announcement_id) {
        userService.updateAnnouncementReadStatus(announcement_id);
        return ApiResponseMe.success("修改成功");
    }

    /**
     * 选择俱乐部详情
     *
     * @param clubId 俱乐部ID
     * @return 包含俱乐部详情的ClubsDetailVO对象的ApiResponseMe对象
     */
    @GetMapping("/selectClubsDetail")
    public ApiResponseMe selectClubsDetail(@RequestParam Long clubId) {
        ClubsDetailVO clubsDetailVO = userService.selectClubsDetail(clubId);
        return ApiResponseMe.success(clubsDetailVO);
    }

    /**
     * 选择俱乐部成员
     *
     * @param clubId 俱乐部ID
     * @return 包含俱乐部成员列表的ApiResponseMe对象
     */
    @GetMapping("/selectClubsMembers")
    public ApiResponseMe selectClubsMembers(@RequestParam Long clubId) {
        List<ClubActivityInfo> list = userService.selectClubsMembers(clubId);
        return ApiResponseMe.success(list);
    }

    /**
     * 更新个人信息
     *
     * @param updatePersonalInfoRequestDto 更新个人信息请求DTO
     * @param file                         用户上传的文件，可能为空
     * @return 包含更新后的用户信息的UserVo对象的ApiResponseMe对象
     */
    @PostMapping("/updatePersonalInfo")
    public ApiResponseMe updatePersonalInfo(@RequestPart("updatePersonalInfoRequestDto") UpdatePersonalInfoRequestDto updatePersonalInfoRequestDto, @RequestPart(name = "file", required = false) MultipartFile file) {
        UserVo userVo = userService.updatePersonalInfos(updatePersonalInfoRequestDto, file);
        return ApiResponseMe.success(userVo);
    }

    /**
     * 获取活动评论
     *
     * @param activityId 活动ID
     * @return 包含活动评论列表的ApiResponseMe对象
     */
    @GetMapping("/comments/{activityId}")
    public ApiResponseMe getComments(@PathVariable Long activityId) {
        List<ActivityCommentVO> comments = userService.getComments(activityId);
        return ApiResponseMe.success(comments);
    }

    /**
     * 创建活动评论
     *
     * @param commentDTO 活动评论DTO，包含评论信息
     * @return 表示评论成功的ApiResponseMe对象
     */
    @PostMapping("/comments")
    public ApiResponseMe createComment(@RequestBody ActivityCommentDTO commentDTO) {
        userService.createComment(commentDTO);
        return ApiResponseMe.shape(true, "评论成功");
    }

    /**
     * 获取指定活动的评论作者ID
     *
     * @param activityId 活动ID
     * @return 包含评论作者ID的ApiResponseMe对象
     */
    @GetMapping("/comments/author/{activityId}")
    public ApiResponseMe getCommentAuthorId(@PathVariable Long activityId) {
        Long authorId = userService.getCommentAuthorId(activityId);
        return ApiResponseMe.success(authorId);
    }

}
